//base
function loadGltf() {
    var scene = viewer.scene;
//base
    var modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63713562,39.99719375, 1.0));        //gltf数据加载位置
    //116.398015-116.397755=0.00026,39.988201-39.988051=0.00015,
    //var model = scene.primitives.add(Cesium.Model.fromGltf({
       // heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
       // url : 'http://localhost:9082/gltf1/CDX01.DAE.gltf',        //如果为bgltf则为.bgltf
       // modelMatrix : modelMatrix,
       // scale : 1     //放大倍数
    //}));
    //var m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    //var m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    //Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    //model.modelMatrix = m;

    //entities
    var position = Cesium.Cartesian3.fromDegrees(115.63713562,39.99719375, 0);
    var heading = Cesium.Math.toRadians(90);
    var pitch = 0;
    var roll = 0;
    var hpr = new Cesium.HeadingPitchRoll(heading, pitch, roll);
    var orientation = Cesium.Transforms.headingPitchRollQuaternion(position, hpr);

    var entity = viewer.entities.add({
        position : position,
        orientation : orientation,
        model : {
            heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
            uri: 'http://localhost:9082/gltf1/CDX01.DAE.gltf'
            //minimumPixelSize : 128,
            //maximumScale : 20000
        }
    });





    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.637211,39.997185, 1.0));        //gltf数据加载位置
    //116.398015-116.397755=0.00026,39.988201-39.988051=0.00015,
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX02.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;


    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.637218,39.99722, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX03.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.637046,39.997195, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX04.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.637242,39.997033, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX05.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;



    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63723957,39.99714031, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX06.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.6372317,39.99706383, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX07.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;
    // model.color =  new Cesium.Color(255,1,1,0.5) ;


    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63723654,39.99706517, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX08.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63713994,39.9969728, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX09.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63723329,39.99710058, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX10.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63700004,39.99694045, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX11.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63697069,39.99704983, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX12.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63697892,39.9971401, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX13.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63706819,39.99716555, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX14.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63692895,39.99695089, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX15.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63700499,39.99705382, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX16.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63701271,39.99714409, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX17.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.6372504,39.99706766, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX18.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63724866,39.99699023, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX19.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63724227,39.99711443, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX20.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63724844,39.997035, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX21.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63723705,39.9970829, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX22.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63723528,39.9970912, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX23.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63724433,39.99704757, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX24.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63710416,39.99708256, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX25.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63729439,39.99709964, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX26.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63729439,39.99709964, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX26.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63708147,39.99642301, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX27.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63708528,39.99649428, 1000.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        //heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX28.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63703967,39.99645804, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX29.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63699408,39.99648947, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX30.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63698321,39.99641226, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX31.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63697034,39.99644865, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX32.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63722325,39.99688792, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX33.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63724931,39.99682484, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX34.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63720902,39.99693681, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX35.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63724251,39.99684601, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX36.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63726911,39.99689995, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX37.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63732111,39.99679254, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX38.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;


    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63726885,39.99678488, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX39.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63741666,39.9967517, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX40.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.637237,39.99676679, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX41.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63727453,39.99708476, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX42.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63730195,39.99710093, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX43.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63732408,39.99724562, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX44.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63726229,39.99688209, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX45.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63725737,39.99688272, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX46.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63725818,39.9969165, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX47.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63724658,39.99691973, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX48.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63724488,39.99694148, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX49.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.6372633,39.99694596, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX50.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63735111,39.99684885, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX51.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63729262,39.99679307, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX52.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63726597,39.99678919, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX53.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63723704,39.99677466, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX54.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63723283,39.99677862, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX55.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63716703,39.99683906, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX56.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.6371428,39.99691612, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX57.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

    modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(
        Cesium.Cartesian3.fromDegrees(115.63709294,39.9968656, 1.0));        //gltf数据加载位置
    model = scene.primitives.add(Cesium.Model.fromGltf({
        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
        url : 'http://localhost:9082/gltf1/CDX58.DAE.gltf',        //如果为bgltf则为.bgltf
        modelMatrix : modelMatrix,
        scale : 1     //放大倍数
    }));
    m = model.modelMatrix;
    //构建一个三阶旋转矩阵。模型旋转一定的角度，fromRotation[Z]来控制旋转轴，toRadians()为旋转角度，转为弧度再参与运算
    m1 = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(-90));

    //矩阵计算
    Cesium.Matrix4.multiplyByMatrix3(m,m1,m);
    //将计算结果再赋值给modelMatrix
    model.modelMatrix = m;

}